// Package sys
// @Link  https://github.com/bufanyun/hotgo
// @Copyright  Copyright (c) 2025 HotGo CLI
// @Author  Ms <133814250@qq.com>
// @License  https://github.com/bufanyun/hotgo/blob/master/LICENSE
// @AutoGenerate Version 2.15.11
package sys

import (
	"context"
	"encoding/json"
	"github.com/gogf/gf/v2/util/gconv"
	"hotgo/internal/dao"
	"hotgo/internal/library/dict"
	"hotgo/internal/library/hgorm/handler"
	"hotgo/internal/model"
	"hotgo/internal/model/entity"
	"hotgo/internal/model/input/sysin"
	"hotgo/internal/service"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
)

type sSysProduct struct{}

func NewSysProduct() *sSysProduct {
	return &sSysProduct{}
}

func init() {
	service.RegisterSysProduct(NewSysProduct())
	dict.RegisterFunc("productOption", "商品选项", service.SysProduct().Option)
}

// Model 商品中心ORM模型
func (s *sSysProduct) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
	return handler.Model(dao.Product.Ctx(ctx), option...)
}

// List 获取商品中心列表
func (s *sSysProduct) List(ctx context.Context, in *sysin.ProductListInp) (list []*sysin.ProductListModel, totalCount int, err error) {
	mod := s.Model(ctx)

	// 字段过滤
	mod = mod.Fields(
		"hg_product.id",
		"hg_product.name",
		"hg_product.type",
		"hg_product.created_at",
		"hg_product.status",
		"hg_product.main_image",
		"hg_product.vip_proportion",
		"hg_product.integral",
		gdb.Raw("GROUP_CONCAT(hg_store.name SEPARATOR '\n') AS store_name"))
	mod = mod.LeftJoin("hg_product_store", "hg_product.id = hg_product_store.product_id")
	mod = mod.LeftJoin("hg_store", "hg_product_store.store_id = hg_store.id")

	// 添加主键条件
	if in.ID > 0 {
		mod = mod.WherePri(in.ID)
	}

	// 添加类型条件
	if in.Type > 0 {
		mod = mod.Where(dao.Product.Columns().Type, in.Type)
	}

	// 查询商品名称
	if in.Name != "" {
		mod = mod.WhereLike(dao.Product.Columns().Name, "%"+in.Name+"%")
	}

	// 查询商品状态
	if in.Status > 0 {
		mod = mod.Where(dao.Product.Columns().Status, in.Status)
	}

	// 添加 adcode 的条件查询
	if in.Adcode != "" {
		if in.Adcode[2:] == "0000" {
			mod = mod.WhereLike("hg_store.adcode", in.Adcode[:2]+"%")
		} else if in.Adcode[4:] == "00" {
			mod = mod.WhereLike("hg_store.adcode", in.Adcode[:4]+"%")
		} else {
			mod = mod.WhereLike("hg_store.adcode", in.Adcode)
		}
	}

	if in.StoreName != "" {
		mod = mod.WhereLike("hg_store.name", "%"+in.StoreName+"%")
	}

	// 分页
	mod = mod.Page(in.Page, in.PerPage)

	mod = mod.Group(dao.Product.Table() + "." + dao.Product.Columns().Id)

	// 查询数据
	if err = mod.Handler(handler.Sorter(in)).ScanAndCount(&list, &totalCount, false); err != nil {
		err = gerror.Wrap(err, "获取商品中心列表失败，请稍后重试！")
		return
	}
	return
}

// Edit 修改/新增商品中心
func (s *sSysProduct) Edit(ctx context.Context, in *sysin.ProductEditInp) (err error) {
	return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {

		addFlag := in.Id == 0

		store := []g.MapStrAny{}
		e := json.Unmarshal(in.StoreId.MustToJson(), &store)
		if e != nil {
			return e
		}

		// 商品门店关联
		if in.Scene == 1 && len(store) > 0 {
			// 获取门店id
			storeIds := make([]int, len(store))
			for i, v := range store {
				storeIds[i] = gconv.Int(v["value"])
			}

			if len(storeIds) > 0 {
				stores := []entity.Store{}
				// 查询门店
				err = dao.Store.Ctx(ctx).WhereIn(dao.Store.Columns().Id, storeIds).Scan(&stores)
				if err != nil {
					err = gerror.Wrap(err, "查询商品门店关联失败，请稍后重试！")
					return
				}
				flag := stores[0].BusinessId
				if flag == 0 && len(stores) > 1 {
					return gerror.New("设置多个门店需要为同一个商户！")
				}
				for _, v := range stores {
					if flag != v.BusinessId {
						return gerror.New("门店关联的商户不一致，请重新选择！")
					}
				}
			}
		}

		if addFlag {
			// 新增
			id, err := s.Model(ctx, &handler.Option{FilterAuth: false}).
				Fields(sysin.ProductInsertFields{}).
				Data(in).OmitEmptyData().InsertAndGetId()
			if err != nil {
				err = gerror.Wrap(err, "新增商品中心失败，请稍后重试！")
			} else {
				in.Id = id
			}
		}

		// 删除商品中心门店关联
		if in.Id > 0 {
			if _, err = dao.ProductStore.Ctx(ctx).Where(dao.ProductStore.Columns().ProductId, in.Id).Delete(); err != nil {
				err = gerror.Wrap(err, "删除商品门店关联失败，请稍后重试！")
				return
			}
		}

		if in.Scene == 1 && len(store) > 0 {
			// 添加商品中心门店关联
			for _, v := range store {
				if _, err = dao.ProductStore.Ctx(ctx).Data().Data(g.Map{
					dao.ProductStore.Columns().ProductId: in.Id,
					dao.ProductStore.Columns().StoreId:   v["value"],
				}).Insert(); err != nil {
					err = gerror.Wrap(err, "添加商品门店关联失败，请稍后重试！")
					break
				}
			}
		}

		// 修改
		if !addFlag && in.Id > 0 {
			if _, err = s.Model(ctx).
				Fields(sysin.ProductUpdateFields{}).
				WherePri(in.Id).Data(in).Update(); err != nil {
				err = gerror.Wrap(err, "修改商品中心失败，请稍后重试！")
			}
			return
		}

		return
	})
}

// View 获取商品中心指定信息
func (s *sSysProduct) View(ctx context.Context, in *sysin.ProductViewInp) (res *sysin.ProductViewModel, err error) {
	if err = s.Model(ctx).WherePri(in.Id).Scan(&res); err != nil {
		err = gerror.Wrap(err, "获取商品中心信息，请稍后重试！")
		return
	}
	return
}

// Status 更新商品中心状态
func (s *sSysProduct) Status(ctx context.Context, in *sysin.ProductStatusInp) (err error) {
	if _, err = s.Model(ctx).WherePri(in.Id).Data(g.Map{
		dao.Product.Columns().Status: in.Status,
	}).Update(); err != nil {
		err = gerror.Wrap(err, "更新商品中心状态失败，请稍后重试！")
		return
	}
	return
}

// Option 获取竞拍活动选项
func (s *sSysProduct) Option(ctx context.Context) (opts []*model.Option, err error) {
	var models []*entity.Auction
	if err = s.Model(ctx).Fields(dao.Product.Columns().Id, dao.Product.Columns().Name).
		OrderDesc(dao.Product.Columns().Id).Scan(&models); err != nil {
		err = gerror.Wrap(err, "获取竞拍活动选项失败！")
		return
	}

	opts = make([]*model.Option, len(models))
	for k, v := range models {
		opts[k] = dict.GenHashOption(v.Id, gconv.String(v.Name))
	}
	return
}
